home *** CD-ROM | disk | FTP | other *** search
/ Libris Britannia 4 / science library(b).zip / science library(b) / CUGUK / GAMES / C059B.ZIP / SRC1.ZIP / APPLY.C < prev    next >
C/C++ Source or Header  |  1990-07-18  |  35KB  |  1,409 lines
  1. /*    SCCS Id: @(#)apply.c    3.0    88/10/24
  2. /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
  3. /* NetHack may be freely redistributed.  See license for details. */
  4.  
  5. #define MONATTK_H    /* comment line for pre-compiled headers */
  6. /* block some unused #defines to avoid overloading some cpp's */
  7. #include    "hack.h"
  8. #include    "edog.h"
  9.  
  10. #ifdef MUSIC
  11. #define IS_INSTRUMENT(typ)    ((typ) >= FLUTE && (typ) <= DRUM_OF_EARTHQUAKE)
  12. #endif /* MUSIC /**/
  13.  
  14. #ifdef OVLB
  15.  
  16. static const char NEARDATA tools[] = { TOOL_SYM, 0 };
  17.  
  18. static boolean NEARDATA did_dig_msg;
  19.  
  20. static struct monst *FDECL(bchit, (int, int, int, CHAR_P));
  21. static void FDECL(use_camera, (struct obj *));
  22. static void FDECL(use_stethoscope, (struct obj *));
  23. static void FDECL(use_whistle, (struct obj *));
  24. static void FDECL(use_magic_whistle, (struct obj *));
  25. #ifdef WALKIES
  26. static void FDECL(use_leash, (struct obj *));
  27. #endif
  28. STATIC_DCL int NDECL(dig);
  29. static boolean FDECL(wield_tool, (struct obj *));
  30. static int FDECL(use_pick_axe, (struct obj *));
  31. #ifdef MEDUSA
  32. static void FDECL(use_mirror, (struct obj *));
  33. #endif
  34. static void FDECL(use_lamp, (struct obj *));
  35. static void FDECL(use_crystal_ball, (struct obj *));
  36. static void FDECL(use_tinning_kit, (struct obj *));
  37.  
  38. /* version of bhit for cameras and mirrors */
  39. static
  40. struct monst *
  41. bchit(ddx,ddy,range,sym) register int ddx,ddy,range; char sym; {
  42.     register struct monst *mtmp = (struct monst *) 0;
  43.     register int bchx = u.ux, bchy = u.uy;
  44.  
  45.     if(sym) {
  46.         Tmp_at2(-1, sym);    /* open call */
  47. #ifdef TEXTCOLOR
  48.         Tmp_at2(-3, WHITE);
  49. #endif
  50.     }
  51.     while(range--) {
  52.         bchx += ddx;
  53.         bchy += ddy;
  54.         if(MON_AT(bchx, bchy)) {
  55.             mtmp = m_at(bchx,bchy);
  56.             break;
  57.         }
  58.         if(!ZAP_POS(levl[bchx][bchy].typ) || closed_door(bchx, bchy)) {
  59.             bchx -= ddx;
  60.             bchy -= ddy;
  61.             break;
  62.         }
  63.         if(sym) Tmp_at2(bchx, bchy);
  64.     }
  65.     if(sym) Tmp_at2(-1, -1);
  66.     return(mtmp);
  67. }
  68.  
  69. static void
  70. use_camera(obj) /* register */ struct obj *obj; {
  71. register struct monst *mtmp;
  72.     if(!getdir(1)){        /* ask: in what direction? */
  73.         flags.move = multi = 0;
  74.         return;
  75.     }
  76.     if(u.uswallow) {
  77.         You("take a picture of %s's %s.", mon_nam(u.ustuck),
  78.             is_animal(u.ustuck->data)? "stomach" : "interior");
  79.         return;
  80.     }
  81.     if(obj->cursed && !rn2(2)) goto blindu;
  82.     if(u.dz) {
  83.         You("take a picture of the %s.",
  84.             (u.dz > 0) ? "floor" : "ceiling");
  85.         return;
  86.     }
  87.     if(!u.dx && !u.dy && !u.dz) {
  88. blindu:
  89.         if(!Blind) {
  90.             You("are blinded by the flash!");
  91.             make_blinded((long)rnd(25),FALSE);
  92.         }
  93.         return;
  94.     }
  95.     if(mtmp = bchit(u.dx, u.dy, COLNO, '!')) {
  96.         if(mtmp->msleep){
  97.             mtmp->msleep = 0;
  98.             pline("The flash awakens %s.", mon_nam(mtmp)); /* a3 */
  99.         } else
  100.         if(mtmp->data->mlet != S_YLIGHT)
  101.         if(mtmp->mcansee || mtmp->mblinded){
  102.             register int tmp = dist(mtmp->mx,mtmp->my);
  103.             register int tmp2;
  104.             if(cansee(mtmp->mx,mtmp->my))
  105.               pline("%s is blinded by the flash!", Monnam(mtmp));
  106.             if(mtmp->data == &mons[PM_GREMLIN]) {
  107.               /* Rule #1: Keep them out of the light. */
  108.               kludge("%s cries out in pain!", Monnam(mtmp));
  109.               if (mtmp->mhp > 1) mtmp->mhp--;
  110.             }
  111.             setmangry(mtmp);
  112.             if(tmp < 9 && !mtmp->isshk && rn2(4)) {
  113.                 mtmp->mflee = 1;
  114.                 if(rn2(4)) mtmp->mfleetim = rnd(100);
  115.             }
  116.             if(tmp < 3) {
  117.                 mtmp->mcansee  = 0;
  118.                 mtmp->mblinded = 0;
  119.             } else {
  120.                 tmp2 = mtmp->mblinded;
  121.                 tmp2 += rnd(1 + 50/tmp);
  122.                 if(tmp2 > 127) tmp2 = 127;
  123.                 mtmp->mblinded = tmp2;
  124.                 mtmp->mcansee = 0;
  125.             }
  126.         }
  127.     }
  128. }
  129.  
  130. /* Strictly speaking it makes no sense for usage of a stethoscope to
  131.    not take any time; however, unless it did, the stethoscope would be
  132.    almost useless. */
  133. static void
  134. use_stethoscope(obj) register struct obj *obj; {
  135. register struct monst *mtmp;
  136. register struct rm *lev;
  137. register int rx, ry;
  138.     if(!freehand()) {
  139.         You("have no free %s!", body_part(HAND));
  140.         return;
  141.     }
  142.     if (!getdir(1)) {
  143.         flags.move=multi=0;
  144.         return;
  145.     }
  146.     if(u.dz < 0 || (u.dz && Levitation)) {
  147.         You("can't reach the %s!", u.dz<0 ? "ceiling" : "floor");
  148.         return;
  149.     }
  150.     if(obj->cursed && !rn2(2)) {
  151.         You("hear your heart beat.");
  152.         return;
  153.     }
  154.     if(u.dz) {
  155. #ifdef STRONGHOLD
  156.         if (dlevel == stronghold_level)
  157.             You("hear the crackling of hellfire.");
  158.         else
  159. #endif
  160.             pline("The floor seems healthy enough.");
  161.         return;
  162.     }
  163.     if (Stunned || (Confusion && !rn2(5))) confdir();
  164.     if (!u.dx && !u.dy && !u.dz) {
  165.         ustatusline();
  166.         return;
  167.     }
  168.     rx = u.ux + u.dx; ry = u.uy + u.dy;
  169.     if(u.uswallow) {
  170.         mstatusline(u.ustuck);
  171.         return;
  172.     }
  173.     if (!isok(rx,ry)) {
  174.         You("hear a faint typing noise.");
  175.         return;
  176.     }
  177.     lev = &levl[rx][ry];
  178.     if(MON_AT(rx, ry)) {
  179.         mtmp = m_at(rx,ry);
  180.         mstatusline(mtmp);
  181.         if (mtmp->mundetected) {
  182.             mtmp->mundetected = 0;
  183.             if (cansee(rx,ry)) pmon(mtmp);
  184.         }
  185.         return;
  186.     }
  187.     if(lev->typ == SDOOR) {
  188.         You("hear a hollow sound!  This must be a secret door!");
  189.         lev->typ = DOOR;
  190.         lev->seen = 0;        /* force prl */
  191.         prl(rx,ry);
  192.         return;
  193.     }
  194.     if(lev->typ == SCORR) {
  195.         You("hear a hollow sound!  This must be a secret passage!");
  196.         lev->typ = CORR;
  197.         lev->seen = 0;        /* force prl */
  198.         prl(rx,ry);
  199.         return;
  200.     }
  201.     You("hear nothing special.");
  202. }
  203.  
  204. /* ARGSUSED */
  205. static void
  206. use_whistle(obj)
  207. struct obj *obj; {
  208.     You("produce a high whistling sound.");
  209.     wake_nearby();
  210. }
  211.  
  212. static void
  213. use_magic_whistle(obj)
  214. struct obj *obj; {
  215.     register struct monst *mtmp = fmon;
  216.  
  217.     if(obj->cursed && !rn2(2)) {
  218.         You("produce a high-pitched humming noise.");
  219.         wake_nearby();
  220.     } else {
  221.         You("produce a %s whistling sound.", Hallucination
  222.             ? "normal" : "strange");
  223.         while(mtmp) {
  224.             if(mtmp->mtame) mnexto(mtmp);
  225.             mtmp = mtmp->nmon;
  226.         }
  227.     }
  228. }
  229.  
  230. boolean
  231. um_dist(x,y,n)
  232. register xchar x, y, n;
  233. {
  234.     return(abs(u.ux - x) > n  || abs(u.uy - y) > n);
  235. }
  236.  
  237. #endif /* OVLB */
  238.  
  239. #ifdef WALKIES
  240. #define MAXLEASHED    2
  241.  
  242. #ifdef OVLB
  243.  
  244. int
  245. number_leashed()
  246. {
  247.     register int i = 0;
  248.     register struct obj *obj;
  249.  
  250.     for(obj = invent; obj; obj = obj->nobj)
  251.         if(obj->otyp == LEASH && obj->leashmon != 0) i++;
  252.     return(i);
  253. }
  254.  
  255. void
  256. o_unleash(otmp)     /* otmp is about to be destroyed or stolen */
  257. register struct obj *otmp;
  258. {
  259.     register struct monst *mtmp;
  260.  
  261.     for(mtmp = fmon; mtmp; mtmp = mtmp->nmon)
  262.         if(mtmp->m_id == (unsigned)otmp->leashmon)
  263.             mtmp->mleashed = 0;
  264.     otmp->leashmon = 0;
  265. }
  266.  
  267. void
  268. m_unleash(mtmp)     /* mtmp is about to die, or become untame */
  269. register struct monst *mtmp;
  270. {
  271.     register struct obj *otmp;
  272.  
  273.     for(otmp = invent; otmp; otmp = otmp->nobj)
  274.         if(otmp->otyp == LEASH &&
  275.                 otmp->leashmon == (int)mtmp->m_id)
  276.             otmp->leashmon = 0;
  277.     mtmp->mleashed = 0;
  278. }
  279.  
  280. void
  281. unleash_all()        /* player is about to die (for bones) */
  282. {
  283.     register struct obj *otmp;
  284.     register struct monst *mtmp;
  285.  
  286.     for(otmp = invent; otmp; otmp = otmp->nobj)
  287.         if(otmp->otyp == LEASH) otmp->leashmon = 0;
  288.     for(mtmp = fmon; mtmp; mtmp = mtmp->nmon)
  289.         if(mtmp->mtame) mtmp->mleashed = 0;
  290. }
  291.  
  292. /* ARGSUSED */
  293. static void
  294. use_leash(obj)
  295. struct obj *obj;
  296. {
  297.     register int x, y;
  298.     register struct monst *mtmp;
  299.  
  300.     if(!obj->leashmon && number_leashed() >= MAXLEASHED) {
  301.         You("can't leash additional pets.");
  302.         return;
  303.     }
  304.  
  305.     if(!getdir(1)) return;
  306.  
  307.     x = u.ux + u.dx;
  308.     y = u.uy + u.dy;
  309.  
  310.     if((x == u.ux) && (y == u.uy)) {
  311.         pline("Leash yourself?  Very funny...");
  312.         return;
  313.     }
  314.  
  315.     if(!MON_AT(x, y)) {
  316.         pline("There is no creature here.");
  317.         return;
  318.     }
  319.  
  320.     mtmp = m_at(x, y);
  321.  
  322.     if(!mtmp->mtame) {
  323.         pline("%s is not %s!", Monnam(mtmp), (!obj->leashmon) ?
  324.                 "leashable" : "leashed");
  325.         return;
  326.     }
  327.     if(!obj->leashmon) {
  328.         if(mtmp->mleashed) {
  329.             pline("This %s is already leashed!", lmonnam(mtmp)+4);
  330.             return;
  331.         }
  332.         You("slip the leash around your %s.", lmonnam(mtmp)+4);
  333.         mtmp->mleashed = 1;
  334.         obj->leashmon = (int)mtmp->m_id;
  335.         if(mtmp->msleep)  mtmp->msleep = 0;
  336.         return;
  337.     }
  338.     if(obj->leashmon != (int)mtmp->m_id) {
  339.         pline("This leash is not attached to that creature!");
  340.         return;
  341.     } else {
  342.         if(obj->cursed) {
  343.             pline("The leash wouldn't come off!");
  344.             return;
  345.         }
  346.         mtmp->mleashed = 0;
  347.         obj->leashmon = 0;
  348.         You("remove the leash from your %s.",
  349.         /* a hack to include the dogs full name.  +4 eliminates */
  350.         /* the 'the' at the start of the name */
  351.                  lmonnam(mtmp)+4);
  352.     }
  353.     return;
  354. }
  355.  
  356. #endif /* OVLB */
  357. #ifdef OVL1
  358.  
  359. boolean
  360. next_to_u()
  361. {
  362.     register struct monst *mtmp;
  363.     register struct obj *otmp;
  364.  
  365.     for(mtmp = fmon; mtmp; mtmp = mtmp->nmon)
  366.         if(mtmp->mleashed) {
  367.             if(dist(mtmp->mx,mtmp->my) > 2) mnexto(mtmp);
  368.             if(dist(mtmp->mx,mtmp->my) > 2) {
  369.                 for(otmp = invent; otmp; otmp = otmp->nobj)
  370.                 if(otmp->otyp == LEASH &&
  371.                     otmp->leashmon == (int)mtmp->m_id) {
  372.                     if(otmp->cursed) return(FALSE);
  373.                     You("feel %s leash go slack.",
  374.                     (number_leashed() > 1) ? "a" : "the");
  375.                     mtmp->mleashed = 0;
  376.                     otmp->leashmon = 0;
  377.                 }
  378.             }
  379.         }
  380.     return(TRUE);
  381. }
  382.  
  383. #endif /* OVL1 */
  384. #ifdef OVLB
  385. struct obj *
  386. get_mleash(mtmp)     /* assuming mtmp->mleashed has been checked */
  387. register struct monst *mtmp;
  388. {
  389.     register struct obj *otmp;
  390.  
  391.     otmp = invent;
  392.     while(otmp) {
  393.         if(otmp->otyp == LEASH && otmp->leashmon == (int)mtmp->m_id)
  394.             return(otmp);
  395.         otmp = otmp->nobj;
  396.     }
  397.     return((struct obj *)0);
  398. }
  399. #endif /* OVLB */
  400.  
  401. #endif /* WALKIES */
  402. #ifdef OVL0
  403.  
  404. #ifdef WALKIES
  405. void
  406. check_leash(x, y)
  407. register xchar x, y;
  408. {
  409.     register struct obj *otmp;
  410.     register struct monst *mtmp = fmon;
  411.  
  412.     for(otmp = invent; otmp; otmp = otmp->nobj)
  413.         if(otmp->otyp == LEASH && otmp->leashmon != 0) {
  414.         while(mtmp) {
  415.             if((int)mtmp->m_id == otmp->leashmon &&
  416.                 (dist2(u.ux,u.uy,mtmp->mx,mtmp->my) >
  417.                 dist2(x,y,mtmp->mx,mtmp->my))
  418.             ) {
  419.             if(otmp->cursed) {
  420.                 if(um_dist(mtmp->mx, mtmp->my, 5)) {
  421.                 pline("%s chokes to death!",Monnam(mtmp));
  422.                 mondied(mtmp);
  423.                 } else
  424.                 if(um_dist(mtmp->mx, mtmp->my, 3))
  425.                     pline("%s chokes on the leash!",
  426.                         Monnam(mtmp));
  427.             } else {
  428.                 if(um_dist(mtmp->mx, mtmp->my, 5)) {
  429.                 pline("%s's leash snaps loose!",Monnam(mtmp));
  430.                 m_unleash(mtmp);
  431.                 } else {
  432.                 if(um_dist(mtmp->mx, mtmp->my, 3)) {
  433.                     You("pull on the leash.");
  434. # ifdef SOUNDS
  435.                     if (mtmp->data->msound != MS_SILENT)
  436.                     switch(rn2(3)) {
  437.                     case 0:  growl(mtmp);    break;
  438.                     case 1:  yelp(mtmp);    break;
  439.                     default: whimper(mtmp); break;
  440.                     }
  441. # endif
  442.                 }
  443.                 }
  444.             }
  445.             }
  446.             mtmp = mtmp->nmon;
  447.         }
  448.         }
  449. }
  450.  
  451. #endif /* WALKIES */
  452.  
  453. #endif /* OVL0 */
  454. #ifdef OVLB
  455.  
  456. STATIC_OVL int
  457. dig() {
  458.     register struct rm *lev;
  459.     register int dpx = dig_pos.x, dpy = dig_pos.y;
  460.  
  461.     lev = &levl[dpx][dpy];
  462.     /* perhaps a nymph stole his pick-axe while he was busy digging */
  463.     /* or perhaps he teleported away */
  464.     if(u.uswallow || !uwep || uwep->otyp != PICK_AXE ||
  465.         dig_level != dlevel ||
  466.         ((dig_down && (dpx != u.ux || dpy != u.uy)) ||
  467.          (!dig_down && dist(dpx,dpy) > 2)))
  468.         return(0);
  469.  
  470.     if(dig_down && is_maze_lev) {
  471.         pline("The floor here is too hard to dig in.");
  472.         return(0);
  473.     }
  474.     if(!dig_down && IS_ROCK(lev->typ) && !may_dig(dpx,dpy)) {
  475.         pline("This wall is too hard to dig into.");
  476.         return(0);
  477.     }
  478.     if(Fumbling && !rn2(3)) {
  479.         switch(rn2(3)) {
  480.         case 0:  if(!welded(uwep)) {
  481.                  You("fumble and drop your %s.", xname(uwep));
  482.                  dropx(uwep);
  483.                  setuwep((struct obj *)0);
  484.              } else {
  485.                  pline("Ouch!  Your %s bounces and hits you!",
  486.                 xname(uwep));
  487.                  set_wounded_legs(RIGHT_SIDE, 5 + rnd(5));
  488.              }
  489.              break;
  490.         case 1:  pline("Bang!  You hit with the broad side of the %s!",
  491.              xname(uwep)); break;
  492.         default: Your("swing misses its mark."); 
  493.              break;
  494.         }
  495.         return(0);
  496.     }
  497.     dig_effort += 10 + abon() + uwep->spe + rn2(5);
  498.     if(dig_down) {
  499.         if(dig_effort > 250) {
  500.             dighole();
  501.             dig_level = -1;
  502.             return(0);    /* done with digging */
  503.         }
  504.         if(dig_effort > 50) {
  505.             register struct trap *ttmp = t_at(dpx,dpy);
  506.  
  507.             if(!ttmp) {
  508.                 ttmp = maketrap(dpx,dpy,PIT);
  509.                 ttmp->tseen = 1;
  510.                 if(Invisible) newsym(ttmp->tx,ttmp->ty);
  511.                 You("have dug a pit.");
  512.                 u.utrap = rn1(4,2);
  513.                 u.utraptype = TT_PIT;
  514.                 dig_level = -1;
  515.                 return(0);
  516.             }
  517.         }
  518.     } else
  519.     if(dig_effort > 100) {
  520.         register const char *digtxt;
  521.         register struct obj *obj;
  522.  
  523.         if(obj = sobj_at(STATUE, dpx, dpy)) {
  524.             if (break_statue(obj))
  525.                 digtxt = "The statue shatters.";
  526.             else
  527.                 /* it was a statue trap; break_statue()
  528.                  * printed a message and updated the screen
  529.                  */
  530.                 digtxt = NULL;
  531.         } else if(obj = sobj_at(BOULDER, dpx, dpy)) {
  532.             fracture_rock(obj);
  533.             digtxt = "The boulder falls apart.";
  534.         } else if(!lev->typ || lev->typ == SCORR) {
  535.             lev->typ = CORR;
  536.             digtxt = "You succeeded in cutting away some rock.";
  537.         } else if(IS_WALL(lev->typ)) {
  538. #ifdef STUPID
  539.                 if (is_maze_lev)
  540.                 lev->typ = ROOM;
  541.             else
  542.                 lev->typ = DOOR;
  543. #else
  544.             lev->typ = is_maze_lev ? ROOM : DOOR;
  545. #endif
  546.             digtxt = "You just made an opening in the wall.";
  547.         } else if(lev->typ == SDOOR) {
  548.             lev->typ = DOOR;
  549.             digtxt = "You just broke through a secret door.";
  550.             if(!(lev->doormask & D_TRAPPED))
  551.                 lev->doormask = D_BROKEN;
  552.         } else if(closed_door(dpx, dpy)) {
  553.             digtxt = "You just broke a hole through the door.";
  554.             if(!(lev->doormask & D_TRAPPED))
  555.                 lev->doormask = D_BROKEN;
  556.         } else return(0); /* statue or boulder got taken */
  557.         mnewsym(dpx, dpy);
  558.         prl(dpx, dpy);
  559.         if (digtxt) pline(digtxt);    /* after mnewsym & prl */
  560.         if(IS_DOOR(lev->typ) && (lev->doormask & D_TRAPPED)) {
  561.             b_trapped("door");
  562.             lev->doormask = D_NODOOR;
  563.             mnewsym(dpx, dpy);
  564.             prl(dpx, dpy);
  565.         }
  566.         dig_level = -1;
  567.         return(0);
  568.     } else {
  569.         if(IS_WALL(lev->typ) || closed_door(dpx, dpy)) {
  570.             register int rno = inroom(dpx,dpy);
  571.  
  572.             if(rno >= 0 && rooms[rno].rtype >= SHOPBASE) {
  573.             pline("This %s seems too hard to dig into.",
  574.             IS_DOOR(lev->typ) ? "door" : "wall");
  575.             return(0);
  576.             }
  577.         } else if (!IS_ROCK(lev->typ) && !sobj_at(STATUE, dpx, dpy)
  578.                 && !sobj_at(BOULDER, dpx, dpy))
  579.             return(0); /* statue or boulder got taken */
  580.         if(!did_dig_msg) {
  581.             You("hit the %s with all your might.",
  582.             sobj_at(STATUE, dpx, dpy) ? "statue" :
  583.             sobj_at(BOULDER, dpx, dpy) ? "boulder" :
  584.             IS_DOOR(lev->typ) ? "door" : "rock");
  585.             did_dig_msg = TRUE;
  586.         }
  587.     }
  588.     return(1);
  589. }
  590.  
  591. /* When will hole be finished? Very rough indication used by shopkeeper. */
  592. int
  593. holetime() {
  594.     if(occupation != dig || !in_shop(u.ux, u.uy)) return(-1);
  595.     return((250 - dig_effort)/20);
  596. }
  597.  
  598. void
  599. dighole()
  600. {
  601.     register struct trap *ttmp = t_at(u.ux, u.uy);
  602.  
  603.     if(is_maze_lev
  604. #ifdef ENDGAME
  605.             || dlevel == ENDLEVEL
  606. #endif
  607.                         ) {
  608.         pline("The floor here seems too hard to dig in.");
  609.     } else {
  610.         if(IS_FURNITURE(levl[u.ux][u.uy].typ)) {
  611. #if defined(ALTARS) && defined(THEOLOGY)
  612.                 if(IS_ALTAR(levl[u.ux][u.uy].typ)) {
  613.                 altar_wrath(u.ux, u.uy);
  614.             if(in_temple(u.ux, u.uy)) angry_priest();
  615.             }
  616. #endif
  617.             levl[u.ux][u.uy].typ = ROOM;
  618.             levl[u.ux][u.uy].altarmask = 0;
  619.         }
  620.         if(ttmp)
  621.             ttmp->ttyp = TRAPDOOR;
  622.         else
  623.             ttmp = maketrap(u.ux, u.uy, TRAPDOOR);
  624.         ttmp->tseen = 1;
  625.         if(Invisible) newsym(ttmp->tx,ttmp->ty);
  626.         pline("You've made a hole in the floor.");
  627.         if(!u.ustuck && !Levitation) {            /* KAA */
  628.             if(in_shop(u.ux, u.uy))
  629.                 shopdig(1);
  630. #ifdef WALKIES
  631.             if(!next_to_u())
  632.                 You("are jerked back by your pet!");
  633.             else {
  634. #endif
  635.                 You("fall through...");
  636.                 if(u.utraptype == TT_PIT) {
  637.                 u.utrap = 0;
  638.                 u.utraptype = 0;
  639.                 }
  640.                 unsee();
  641. #ifdef MACOS
  642.                 segments |= SEG_APPLY;
  643. #endif
  644.                 goto_level(dlevel+1, FALSE, TRUE);
  645. #ifdef WALKIES
  646.             }
  647. #endif
  648.         }
  649.     }
  650. }
  651.  
  652. static boolean
  653. wield_tool(obj)
  654. struct obj *obj;
  655. {
  656.     if(uwep && uwep->cursed) {
  657.         /* Andreas Bormann - ihnp4!decvax!mcvax!unido!ab */
  658.         if(flags.verbose) {
  659.             pline("Since your weapon is welded to your %s,",
  660.                 bimanual(uwep) ?
  661.                 makeplural(body_part(HAND))
  662.                 : body_part(HAND));
  663.             pline("you cannot wield that %s.", xname(obj));
  664.         }
  665.         return(FALSE);
  666.     }
  667. # ifdef POLYSELF
  668.     if(cantwield(uasmon)) {
  669.         You("can't hold it strongly enough.");
  670.         return(FALSE);
  671.     }
  672. # endif
  673.     unweapon = TRUE;
  674.     You("now wield %s.", doname(obj));
  675.     setuwep(obj);
  676.     if (uwep != obj) return(FALSE); /* rewielded old object after dying */
  677.     return(TRUE);
  678. }
  679.  
  680. static int
  681. use_pick_axe(obj)
  682. struct obj *obj;
  683. {
  684.     char dirsyms[12];
  685.     register char *dsp = dirsyms;
  686.     register const char *sdp = flags.num_pad ? ndir : sdir;
  687.     register struct rm *lev;
  688.     register int rx, ry, res = 0;
  689.     register boolean isclosedoor = FALSE;
  690.  
  691.     if(obj != uwep)
  692.         if (!wield_tool(obj)) return(0);
  693.         else res = 1;
  694.  
  695.     while(*sdp) {
  696.         (void) movecmd(*sdp);    /* sets u.dx and u.dy and u.dz */
  697.         rx = u.ux + u.dx;
  698.         ry = u.uy + u.dy;
  699.         if(u.dz > 0 || (u.dz == 0 && isok(rx, ry) &&
  700.             (IS_ROCK(levl[rx][ry].typ)
  701.             || sobj_at(STATUE, rx, ry)
  702.             || sobj_at(BOULDER, rx, ry))))
  703.             *dsp++ = *sdp;
  704.         sdp++;
  705.     }
  706.     *dsp = 0;
  707.     pline("In what direction do you want to dig? [%s] ", dirsyms);
  708.     if(!getdir(0))        /* no txt */
  709.         return(res);
  710.     if(u.uswallow && attack(u.ustuck)) /* return(1) */;
  711.     else if(u.dz < 0) You("cannot reach the ceiling.");
  712.     else if(!u.dx && !u.dy && !u.dz) {
  713.         char buf[BUFSZ];
  714.         int dam;
  715.  
  716.         dam = rnd(2) + dbon() + obj->spe;
  717.         if (dam <= 0) dam = 1;
  718.         You("hit yourself with your own pick-axe.");
  719.         /* self_pronoun() won't work twice in a sentence */
  720.         Strcpy(buf, self_pronoun("killed %sself with %%s own pick-axe",
  721.             "him"));
  722.         losehp(dam, self_pronoun(buf, "his"), NO_KILLER_PREFIX);
  723.         flags.botl=1;
  724.         return(1);
  725.     } else if(u.dz == 0) {
  726.         if(Stunned || (Confusion && !rn2(5))) confdir();
  727.         rx = u.ux + u.dx;
  728.         ry = u.uy + u.dy;
  729.         lev = &levl[rx][ry];
  730.         if(MON_AT(rx, ry) && attack(m_at(rx, ry)))
  731.             return(1);
  732.         if(!isok(rx, ry)) {
  733.             pline("Clash!");
  734.             return(1);
  735.         }
  736.         isclosedoor = closed_door(rx, ry);
  737.         if(!IS_ROCK(lev->typ)
  738.              && !isclosedoor
  739.              && !sobj_at(STATUE, rx, ry)
  740.              && !sobj_at(BOULDER, rx, ry)) {
  741.             /* ACCESSIBLE or POOL */
  742.             You("swing your %s through thin air.",
  743.                 aobjnam(obj, NULL));
  744.         } else {
  745.             if(dig_pos.x != rx || dig_pos.y != ry
  746.                 || dig_level != dlevel || dig_down) {
  747.                 dig_down = FALSE;
  748.                 dig_pos.x = rx;
  749.                 dig_pos.y = ry;
  750.                 dig_level = dlevel;
  751.                 dig_effort = 0;
  752.                     You("start %s.",
  753.                    sobj_at(STATUE, rx, ry) ?
  754.                         "chipping the statue" :
  755.                    sobj_at(BOULDER, rx, ry) ?
  756.                         "hitting the boulder" :
  757.                    isclosedoor ? "chopping at the door" :
  758.                         "digging");
  759.             } else
  760.                 You("continue %s.",
  761.                    sobj_at(STATUE, rx, ry) ?
  762.                         "chipping the statue" :
  763.                    sobj_at(BOULDER, rx, ry) ?
  764.                         "hitting the boulder" :
  765.                    isclosedoor ? "chopping at the door" :
  766.                         "digging");
  767.             did_dig_msg = FALSE;
  768.             set_occupation(dig, "digging", 0);
  769.         }
  770.     } else if(Levitation) {
  771.         You("cannot reach the floor.");
  772.     } else {
  773.         if(dig_pos.x != u.ux || dig_pos.y != u.uy
  774.             || dig_level != dlevel || !dig_down) {
  775.             dig_down = TRUE;
  776.             dig_pos.x = u.ux;
  777.             dig_pos.y = u.uy;
  778.             dig_level = dlevel;
  779.             dig_effort = 0;
  780.             You("start digging in the floor.");
  781.             if(in_shop(u.ux, u.uy))
  782.                 shopdig(0);
  783.         } else
  784.             You("continue digging in the floor.");
  785.         did_dig_msg = FALSE;
  786.         set_occupation(dig, "digging", 0);
  787.     }
  788.     return(1);
  789. }
  790.  
  791. #define WEAK    3    /* from eat.c */
  792.  
  793. #ifdef MEDUSA
  794. static void
  795. use_mirror(obj)
  796. struct obj *obj;
  797. {
  798.     register struct monst *mtmp;
  799.     register char mlet;
  800.  
  801.     if(!getdir(1)){        /* ask: in what direction? */
  802.         flags.move = multi = 0;
  803.         return;
  804.     }
  805.     if(obj->cursed && !rn2(2)) {
  806.         if (!Blind)
  807.             pline("The mirror gets foggy and doesn't reflect!");
  808.         return;
  809.     }
  810.     if(!u.dx && !u.dy && !u.dz) {
  811.         if(!Blind && !Invisible) {
  812. #ifdef POLYSELF
  813.             if(u.umonnum == PM_FLOATING_EYE) {
  814.             pline("Yikes!  You've frozen yourself!");
  815.             nomul(-rnd((MAXULEV+6) - (int)u.ulevel));
  816.             } else if (u.usym == S_VAMPIRE || u.usym == S_DEMON)
  817.             You("don't seem to reflect anything.");
  818.             else if(u.umonnum == PM_UMBER_HULK) {
  819.             pline("Huh?  That doesn't look like you!");
  820.             make_confused(HConfusion + d(3,4),FALSE);
  821.             } else
  822. #endif
  823.                if (Hallucination) You("look %s.", hcolor());
  824.             else if (Sick)
  825.             You("look peaked.");
  826.             else if (u.uhs >= WEAK)
  827.             You("look undernourished.");
  828. #ifdef POLYSELF
  829.             else if (u.usym == S_NYMPH
  830. #ifdef INFERNO
  831.                  || u.umonnum==PM_SUCCUBUS
  832. #endif
  833.                  )
  834.             You("look beautiful in the mirror.");
  835. #ifdef INFERNO
  836.             else if (u.umonnum == PM_INCUBUS)
  837.             You("look handsome in the mirror.");
  838. #endif
  839. #endif
  840.             else You("look as %s as ever.",
  841.                 ACURR(A_CHA) > 14 ?
  842.                 (poly_gender()==1 ? "beautiful" : "handsome") :
  843.                 "ugly");
  844.         } else {
  845.         if (Luck <= 10 && rn2(4-Luck/3) || !HTelepat ||
  846.             (u.ukilled_medusa
  847. #ifdef HARD
  848.             && u.udemigod
  849. #endif
  850.             )) {
  851.             You("can't see your %s %s.",
  852.                 ACURR(A_CHA) > 14 ?
  853.                 (poly_gender()==1 ? "beautiful" : "handsome") :
  854.                 "ugly",
  855.                 body_part(FACE));
  856.         } else {
  857.             static char buf[35];
  858.             const char *tm, *tl; int ll;
  859.             if (!u.ukilled_medusa && rn2(4)) {
  860.                 tm = "n ugly snake-headed monster";
  861.                 ll = dlevel - medusa_level;
  862.             }
  863.             else {
  864.                 tm = " powerful wizard";
  865.                 ll = dlevel - wiz_level;
  866.             }
  867.             if (ll < -10) tl = "far below you";
  868.             else if (ll < -1) tl = "below you";
  869.             else if (ll == -1) {
  870.                 Sprintf(buf, "under your %s", makeplural(
  871.                 body_part(FOOT)));
  872.                 tl = buf;
  873.             } else if (ll == 0)  tl = "very close to you";
  874.             else if (ll == 1) {
  875.                 Sprintf(buf, "above your %s", body_part(HEAD));
  876.                 tl = buf;
  877.             } else if (ll > 10) tl = "far above you";
  878.             else tl = "above you";
  879.             You("get an impression that a%s lives %s.",
  880.                 tm, tl);
  881.             }
  882.         }
  883.         return;
  884.     }
  885.     if(u.uswallow) {
  886.         You("reflect %s's %s.", mon_nam(u.ustuck), 
  887.             is_animal(u.ustuck->data)? "stomach" : "interior");
  888.         return;
  889.     }
  890.     if(u.dz) {
  891.         You("reflect the %s.",
  892.             (u.dz > 0) ? "floor" : "ceiling");
  893.         return;
  894.     }
  895.     if(!(mtmp = bchit(u.dx, u.dy, COLNO, 0)) || !haseyes(mtmp->data))
  896.         return;
  897.  
  898.     mlet = mtmp->data->mlet;
  899.     if(mtmp->msleep) {
  900.         if(!Blind)
  901.             pline ("%s is tired and doesn't look at your mirror.",
  902.                 Monnam(mtmp));
  903.         mtmp->msleep = 0;
  904.     } else if (!mtmp->mcansee) {
  905.         if (!Blind)
  906.             pline("%s can't see anything at the moment.", Monnam(mtmp));
  907.     /* some monsters do special things */
  908.     } else if (mlet == S_VAMPIRE || mlet == S_DEMON || mlet == S_GHOST ||
  909.           (mtmp->minvis && !perceives(mtmp->data) && !See_invisible)) {
  910.         if (!Blind)
  911.            pline ("%s doesn't seem to reflect anything.", Monnam(mtmp));
  912.     } else if(!mtmp->mcan && mtmp->data == &mons[PM_MEDUSA]) {
  913.         if (!Blind)
  914.             pline("%s is turned to stone!", Monnam(mtmp));
  915.         stoned = TRUE;
  916.         killed(mtmp);
  917.     } else if(!mtmp->mcan && !mtmp->minvis &&
  918.                     mtmp->data == &mons[PM_FLOATING_EYE]) {
  919.         int tmp = d((int)mtmp->m_lev, (int)mtmp->data->mattk[0].damd);
  920.         if (!rn2(4)) tmp = 120;
  921.     /* Note: floating eyes cannot use their abilities while invisible,
  922.      * but medusas and umber hulks can.
  923.      */
  924.         if (!Blind)
  925.             pline("%s is frozen by its reflection.",Monnam(mtmp));
  926.         mtmp->mcanmove = 0;
  927.         if (mtmp->mfrozen + tmp > 127)
  928.             mtmp->mfrozen = 127;
  929.         else mtmp->mfrozen += tmp;
  930.     } else if(!mtmp->mcan && mtmp->data == &mons[PM_UMBER_HULK]) {
  931.         if (!Blind)
  932.             pline ("%s has confused itself!", Monnam(mtmp));
  933.             mtmp->mconf = 1;
  934.     } else if(!mtmp->mcan && !mtmp->minvis && (mlet == S_NYMPH
  935. #ifdef INFERNO
  936.               || mtmp->data==&mons[PM_SUCCUBUS]
  937. #endif
  938.               )) {
  939.         if (!Blind) {
  940.                 pline ("%s looks beautiful in your mirror.",Monnam(mtmp));
  941.                 pline ("She decides to take it!");
  942.         } else pline ("It steals your mirror!");
  943.         setnotworn(obj); /* in case mirror was wielded */
  944.             freeinv(obj);
  945.             mpickobj(mtmp,obj);
  946.             rloc(mtmp);
  947.     } else if (mlet != S_UNICORN && !humanoid(mtmp->data) && 
  948.             (!mtmp->minvis || perceives(mtmp->data)) && rn2(5)) {
  949.         if (!Blind)
  950.             pline ("%s is frightened by its reflection%s.",
  951.                 Monnam(mtmp), (mtmp->minvis && !See_invisible
  952.                     && !Telepat) ?
  953.                 ", though you see nothing" : "");
  954.         mtmp->mflee = 1;
  955.         mtmp->mfleetim += d(2,4);
  956.     } else if (!Blind) {
  957.         if (mtmp->minvis && !See_invisible)
  958.             pline("%s doesn't seem to reflect anything.",
  959.             Monnam(mtmp));
  960.         else if (mtmp->minvis && !perceives(mtmp->data))
  961.             pline("%s doesn't seem to be aware of its reflection.",
  962.             Monnam(mtmp));
  963.         else
  964.             pline("%s doesn't seem to mind %s reflection.",
  965.             Monnam(mtmp), (is_female(mtmp) ? "her" :
  966.                 is_human(mtmp->data) ? "his" : "its"));
  967.     }
  968. }/* use_mirror */
  969.  
  970. #endif
  971.  
  972. static void
  973. use_lamp(obj)
  974. struct obj *obj;
  975. {
  976.     if(obj->spe <= 0 || obj->otyp == MAGIC_LAMP ) {
  977.         pline("This lamp has no oil.");
  978.         return;
  979.     }
  980.     if(obj->cursed && !rn2(2))
  981.         pline("The lamp flickers on for a moment and dies.");
  982.     else litroom(TRUE);
  983.     obj->spe -= 1;
  984. }
  985.  
  986. static void
  987. use_crystal_ball(obj)
  988.     struct obj *obj;
  989. {
  990.     char buf[BUFSZ];
  991.     int oops, ret;
  992.  
  993.     if (Blind) {
  994.         pline("Too bad you can't see the crystal ball.");
  995.         return;
  996.     }
  997.     oops = (rnd(20) > ACURR(A_INT) || obj->cursed);
  998.     if (oops && (obj->spe > 0)) {
  999.         switch(rnd(5)) {
  1000.         case 1 : pline("The crystal ball is too much to comprehend!");
  1001.             break;
  1002.         case 2 : pline("The crystal ball confuses you!");
  1003.             make_confused(HConfusion + rnd(100),FALSE);
  1004.             break;
  1005.         case 3 : pline("The crystal ball damages your vision!");
  1006.             make_blinded(Blinded + rnd(100),FALSE);
  1007.             break;
  1008.         case 4 : pline("The crystal ball zaps your mind!");
  1009.             make_hallucinated(Hallucination + rnd(100),FALSE);
  1010.             break;
  1011.         case 5 : pline("The crystal ball explodes!");
  1012.             useup(obj);
  1013.             losehp(rnd(30), "exploding crystal ball",
  1014.                 KILLED_BY_AN);
  1015.             break;
  1016.         }
  1017.         obj->spe -= 1;
  1018.         return;
  1019.     }
  1020.  
  1021.     pline("What do you want to look for? ");
  1022.     getlin(buf);
  1023.     clrlin();
  1024.     if (!buf[0] || buf[0] == '\033') {
  1025.         if(flags.verbose) pline("Never mind.");
  1026.         return;
  1027.         }
  1028.     You("peer into the crystal ball.");
  1029.     nomul(-rnd(10));
  1030.     nomovemsg = "";
  1031.     if(obj->spe <= 0)
  1032.         pline("The vision is unclear.");
  1033.     else {
  1034.           obj->spe -= 1;
  1035.         switch(buf[0]) {
  1036.         case GOLD_SYM :    ret = gold_detect((struct obj *)0);
  1037.             break;
  1038.         case '^' :    ret = trap_detect((struct obj *)0);
  1039.             break;
  1040.         case FOOD_SYM :    ret = food_detect((struct obj *)0);
  1041.             break;
  1042.         case POTION_SYM :
  1043.         case GEM_SYM :
  1044.         case TOOL_SYM :
  1045.         case WEAPON_SYM :
  1046.         case WAND_SYM :
  1047.         case SCROLL_SYM :
  1048. #ifdef SPELLS
  1049.         case SPBOOK_SYM :
  1050. #endif
  1051.         case ARMOR_SYM :    ret = object_detect((struct obj *)0);
  1052.             break;
  1053.         default  : lcase(buf);
  1054.             if (!strncmp(buf,"gold",4) || !strncmp(buf,"money",5))
  1055.                 ret = gold_detect((struct obj *)0);
  1056.             else if (!strncmp(buf,"trap",4))
  1057.                 ret = trap_detect((struct obj *)0);
  1058.             else if (!strncmp(buf,"food",4) ||
  1059.                  !strncmp(buf,"dead",4) ||
  1060.                  !strncmp(buf,"corpse",6))
  1061.                 ret = food_detect((struct obj *)0);
  1062.             else if (!strncmp(buf,"obj",3) ||
  1063.                  !strncmp(buf,"the",3) ||
  1064.                  !strncmp(buf,"a ",2) ||
  1065.                  !strncmp(buf,"an ",3))
  1066.                  /* || strstr(buf, " of") */
  1067.                 ret = object_detect((struct obj *)0);
  1068.             else ret = monster_detect((struct obj *)0);
  1069.             break;
  1070.         }
  1071.         if (ret)
  1072.             if (!rn2(100))  /* make them nervous */
  1073.             You("see the Wizard of Yendor gazing out at you.");
  1074.             else pline("The vision is unclear.");
  1075.     }
  1076.     return;
  1077. }
  1078.  
  1079. static const char NEARDATA cuddly[] = { TOOL_SYM, 0 };
  1080.  
  1081. int
  1082. dorub()
  1083. {
  1084.     struct obj *obj = getobj(cuddly, "rub");
  1085.  
  1086.     if(!obj || (obj != uwep && !wield_tool(obj))) return 0;
  1087.  
  1088.     /* now uwep is obj */
  1089.     if (uwep->otyp == MAGIC_LAMP) {
  1090.         if (uwep->spe > 0 && !rn2(3)) {
  1091.         uwep->spe = 0;
  1092.         djinni_from_bottle(uwep);
  1093.         makeknown(MAGIC_LAMP);
  1094.         } else if (rn2(2) && !Blind)
  1095.         You("see a puff of smoke.");
  1096.         else pline(nothing_happens);
  1097.     } else pline(nothing_happens);
  1098.     return 1;
  1099. }
  1100.  
  1101. int
  1102. dojump()
  1103. {
  1104.     coord cc;
  1105.     register struct monst *mtmp;
  1106.     if (!Jumping) {
  1107.         You("can't jump very far.");
  1108.         return 0;
  1109.     } else if (u.uswallow) {
  1110.         pline("You've got to be kidding!");
  1111.         return 0;
  1112.     } else if (u.ustuck) {
  1113.         kludge("You cannot escape from %s!",
  1114.             mon_nam(u.ustuck));
  1115.         return 0;
  1116.     } else if (inv_weight() > -5) {
  1117.         You("are carrying too much to jump!");
  1118.         return 0;
  1119.     } else if (u.uhunger <= 100 || ACURR(A_STR) < 6) {
  1120.         You("lack the strength to jump!");
  1121.         return 0;
  1122.     }
  1123.     pline("Where do you want to jump?");
  1124.     cc.x = u.ux;
  1125.     cc.y = u.uy;
  1126.     getpos(&cc, 1, "the desired position");
  1127.     if (dist(cc.x, cc.y) > 9) {
  1128.         pline("Too far!");
  1129.         return 0;
  1130.     } else if (!cansee(cc.x, cc.y)) {
  1131.         You("cannot see where to land!");
  1132.         return 0;
  1133.     } else if (MON_AT(cc.x, cc.y)) {
  1134.         mtmp = m_at(cc.x, cc.y);
  1135.         You("cannot trample %s!", mon_nam(mtmp));
  1136.         return 0;
  1137.     } else if (!isok(cc.x, cc.y) ||
  1138. #ifdef POLYSELF
  1139.         (IS_ROCK(levl[cc.x][cc.y].typ) && !passes_walls(uasmon)) ||
  1140. #else
  1141.         IS_ROCK(levl[cc.x][cc.y].typ) ||
  1142. #endif
  1143.         sobj_at(BOULDER, cc.x, cc.x) ) {
  1144.             You("cannot jump there!");
  1145.             return 0;
  1146.     } else {
  1147.             teleds(cc.x, cc.y);
  1148.             nomul(-1);
  1149.             nomovemsg = "";
  1150.             morehungry(rnd(25));
  1151.             return 1;
  1152.     }
  1153. }
  1154.  
  1155. static void
  1156. use_tinning_kit(obj)
  1157. register struct obj *obj;
  1158. {
  1159.     register struct obj *corpse, *can = (struct obj *)0;
  1160.  
  1161.     /* This takes only 1 move.  If this is to be changed to take many
  1162.      * moves, we've got to deal with decaying corpses...
  1163.      */
  1164.     if (!(corpse = floorfood("can", 1))) return;
  1165.     if (corpse->oeaten) {
  1166.         You("cannot tin something which is partly eaten.");
  1167.         return;
  1168.     }
  1169.     if ((corpse->corpsenm == PM_COCKATRICE)
  1170. #ifdef POLYSELF
  1171.         && !resists_ston(uasmon)
  1172. #endif
  1173.         && !uarmg) {
  1174. pline("Tinning a cockatrice corpse without gloves was not a very wise move...");
  1175.         You("turn to stone...");
  1176.         killer_format = KILLED_BY;
  1177.         killer = "trying to tin a cockatrice without gloves";
  1178.         done(STONING);
  1179.     }
  1180.     if (mons[corpse->corpsenm].cnutrit == 0) {
  1181.         You("can't tin something that insubstantial!");
  1182.         return;
  1183.     }
  1184.     if(can = mksobj(TIN,FALSE)) {
  1185.         int savequan;
  1186.  
  1187.         can->corpsenm = corpse->corpsenm;
  1188.         can->quan = 1; /*Defeat the occasional creation of pairs of tins */
  1189.         can->owt = weight(can);
  1190.         can->known = 1;
  1191.         can->spe = -1; /* Mark tinned tins. No spinach allowed... */
  1192.         can->cursed = obj->cursed;
  1193.         can->blessed = obj->blessed;
  1194.         can = addinv(can);
  1195.         savequan = can->quan;
  1196.         can->quan = 1;
  1197.         if (inv_cnt() <= 52) {
  1198.         prinv(can);
  1199.         can->quan = savequan;
  1200.         } else {
  1201.         pline("You make, but cannot pick up, %s.", doname(can));
  1202.         /* can->quan = savequan; */
  1203.         /* unnecessary since savequan = quan = 1 here */
  1204.         dropx(can);
  1205.         }
  1206.         if (carried(corpse)) useup(corpse);
  1207.         else useupf(corpse);
  1208.     } else impossible("Tinning failed.");
  1209. }
  1210.  
  1211. int
  1212. use_unicorn_horn(obj)
  1213. struct obj *obj;
  1214. {
  1215.     boolean blessed = (obj && obj->blessed);
  1216.     boolean did_something = FALSE;
  1217.  
  1218.     if (obj && obj->cursed) {
  1219.         switch (rn2(6)) {
  1220.             static char buf[BUFSZ];
  1221.             case 0: make_sick(Sick ? 1L : (long)(20 + rn2(20)), TRUE);
  1222.                 Strcpy(buf, xname(obj));
  1223.                 u.usick_cause = (const char *)buf;
  1224.                 break;
  1225.             case 1: make_blinded(Blinded + (long) rnd(100), TRUE);
  1226.                 break;
  1227.             case 2: if (!Confusion)
  1228.                 You("suddenly feel %s.",
  1229.                     Hallucination ? "trippy" : "confused");
  1230.                 make_confused(HConfusion + (long) rnd(100), TRUE);
  1231.                 break;
  1232.             case 3: make_stunned(HStun + (long) rnd(100), TRUE);
  1233.                 break;
  1234.             case 4: adjattrib(rn2(6), -1, FALSE);
  1235.                 break;
  1236.             case 5: make_hallucinated(Hallucination + (long) rnd(100),
  1237.                 TRUE);
  1238.                 break;
  1239.         }
  1240.         return 1;
  1241.     }
  1242.         
  1243.     if (Sick) {
  1244.         make_sick(0L, TRUE);
  1245.         did_something++;
  1246.     }
  1247.     if (Blinded > (long)(u.ucreamed+1) && (!did_something || blessed)) {
  1248.         make_blinded(u.ucreamed ? (long)(u.ucreamed+1) : 0L, TRUE);
  1249.         did_something++;
  1250.     }
  1251.     if (Hallucination && (!did_something || blessed)) {
  1252.         make_hallucinated(0L, TRUE);
  1253.         did_something++;
  1254.     }
  1255.     if (Vomiting && (!did_something || blessed)) {
  1256.         make_vomiting(0L, TRUE);
  1257.         did_something++;
  1258.     }
  1259.     if (HConfusion && (!did_something || blessed)) {
  1260.         make_confused(0L, TRUE);
  1261.         did_something++;
  1262.     }
  1263.     if (HStun && (!did_something || blessed)) {
  1264.         make_stunned(0L, TRUE);
  1265.         did_something++;
  1266.     }
  1267.     if (!did_something || blessed) {
  1268.         register int j;
  1269.         int did_stat = 0;
  1270.         int i = rn2(A_MAX);
  1271.         for(j=0; j<A_MAX; j++) {
  1272.             if ((blessed || j==i) && ABASE(i) < AMAX(i)) {
  1273.                 did_something++;
  1274.                 /* They may have to use it several times... */
  1275.                 if (!did_stat) {
  1276.                     did_stat++;
  1277.                     pline("This makes you feel good!");
  1278.                 }
  1279.                 ABASE(i)++;
  1280.                 flags.botl = 1;
  1281.             }
  1282.         }
  1283.     }
  1284.     if (!did_something) pline(nothing_happens);
  1285.     return !!did_something;
  1286. }
  1287.  
  1288. int
  1289. doapply() {
  1290.     register struct obj *obj;
  1291.     register int res = 1;
  1292.  
  1293.     obj = getobj(tools, "use or apply");
  1294.     if(!obj) return 0;
  1295.  
  1296.     check_unpaid(obj);
  1297.  
  1298. #ifdef MUSIC
  1299.     if (IS_INSTRUMENT(obj->otyp)) {
  1300.         res = do_play_instrument(obj);
  1301.         return (res);
  1302.     }
  1303. #endif /* MUSIC /**/
  1304.  
  1305.     switch(obj->otyp){
  1306.     case EXPENSIVE_CAMERA:
  1307.         use_camera(obj); break;
  1308.     case CREDIT_CARD:
  1309.     case LOCK_PICK:
  1310.     case SKELETON_KEY:
  1311.     case KEY:
  1312.         (void) pick_lock(obj);
  1313.         break;
  1314.     case BAG_OF_TRICKS:
  1315.         if(obj->spe > 0) {
  1316.             register int cnt = 1;
  1317.  
  1318.             obj->spe -= 1;
  1319.             if(!rn2(23)) cnt += rn2(7) + 1;
  1320.             while(cnt--)
  1321.                 (void) makemon((struct permonst *) 0, u.ux, u.uy);
  1322.             makeknown(BAG_OF_TRICKS);
  1323.         }
  1324.         break;
  1325.     case LARGE_BOX:
  1326.     case CHEST:
  1327.     case ICE_BOX:
  1328.     case SACK:
  1329.     case BAG_OF_HOLDING:
  1330.         use_container(obj, 1); break;
  1331.     case PICK_AXE:
  1332.         res = use_pick_axe(obj);
  1333.         break;
  1334.     case TINNING_KIT:
  1335.         use_tinning_kit(obj);
  1336.         break;
  1337.     case MAGIC_WHISTLE:
  1338.         if(pl_character[0] == 'W' || u.ulevel > (MAXULEV/3)) {
  1339.             use_magic_whistle(obj);
  1340.             break;
  1341.         }
  1342.         /* fall into next case */
  1343.     case WHISTLE:
  1344.         use_whistle(obj);
  1345.         break;
  1346. #ifdef MEDUSA
  1347.     case MIRROR:
  1348.         use_mirror(obj);
  1349.         break;
  1350. #endif
  1351.     case LAMP:
  1352.     case MAGIC_LAMP:
  1353.         use_lamp(obj);
  1354.         break;
  1355.     case CRYSTAL_BALL:
  1356.         use_crystal_ball(obj);
  1357.         break;
  1358. #ifdef WALKIES
  1359.     case LEASH:
  1360.         use_leash(obj);
  1361.         break;
  1362. #endif
  1363.     case MAGIC_MARKER:
  1364.         dowrite(obj);
  1365.         break;
  1366.     case TIN_OPENER:
  1367.         if(!carrying(TIN)) {
  1368.             You("have no tin to open.");
  1369.             goto xit;
  1370.         }
  1371.         You("cannot open a tin without eating or discarding its contents.");
  1372.         if(flags.verbose)
  1373.             pline("In order to eat, use the 'e' command.");
  1374.         if(obj != uwep)
  1375.     pline("Opening the tin will be much easier if you wield the tin opener.");
  1376.         goto xit;
  1377.  
  1378.     case STETHOSCOPE:
  1379.         res = 0;
  1380.         use_stethoscope(obj);
  1381.         break;
  1382.     case FIGURINE:
  1383.         You("set the figurine on the ground and it transforms.");
  1384.         make_familiar(obj);
  1385.         useup(obj);
  1386.         break;
  1387.     case BLINDFOLD:
  1388.         if (obj == ublindf) {
  1389.             if(cursed(obj)) break;
  1390.             else Blindf_off(obj);
  1391.         } 
  1392.         else if (!ublindf) Blindf_on(obj);
  1393.         else You("are already wearing a blindfold!");
  1394.         break;
  1395.     case UNICORN_HORN:
  1396.         res = use_unicorn_horn(obj);
  1397.         break;
  1398.     default:
  1399.         pline("Sorry, I don't know how to use that.");
  1400.     xit:
  1401.         nomul(0);
  1402.         return 0;
  1403.     }
  1404.     nomul(0);
  1405.     return res;
  1406. }
  1407.  
  1408. #endif /* OVLB */
  1409.